home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / demos / OpenGL / walker / walkviewer.c < prev    next >
C/C++ Source or Header  |  1996-11-11  |  13KB  |  493 lines
  1. /*
  2.  * walkviewer.c [from agviewer.c  (version 1.0)]
  3.  *
  4.  * AGV: a glut viewer. Routines for viewing a 3d scene w/ glut
  5.  *
  6.  * See agv_example.c and agviewer.h comments within for more info.
  7.  *
  8.  * I welcome any feedback or improved versions!
  9.  *
  10.  * Philip Winston - 4/11/95
  11.  * pwinston@hmc.edu
  12.  * http://www.cs.hmc.edu/people/pwinston
  13.  */
  14.  
  15. #include <GL/gl.h>
  16. #include <GL/glu.h>
  17. #include <GL/glut.h>
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <math.h>
  21.  
  22. #include "walkviewer.h"
  23.  
  24. /***************************************************************/
  25. /************************** SETTINGS ***************************/
  26. /***************************************************************/
  27.  
  28.    /* Initial polar movement settings */
  29. #define INIT_POLAR_AZ  0.0
  30. #define INIT_POLAR_EL 30.0
  31. #define INIT_DIST      3.0
  32. #define INIT_AZ_SPIN   0.5
  33. #define INIT_EL_SPIN   0.0
  34.  
  35.   /* Initial flying movement settings */
  36. #define INIT_EX        0.0
  37. #define INIT_EY       -2.0
  38. #define INIT_EZ       -2.0
  39. #define INIT_MOVE     0.01
  40. #define MINMOVE      0.001    
  41.  
  42.   /* Start in this mode */
  43. #define INIT_MODE   POLAR   
  44.  
  45.   /* Controls:  */
  46.  
  47.   /* map 0-9 to an EyeMove value when number key is hit in FLYING mode */
  48. #define SPEEDFUNCTION(x) ((x)*(x)*0.001)  
  49.  
  50.   /* Multiply EyeMove by (1+-MOVEFRACTION) when +/- hit in FLYING mode */
  51. #define MOVEFRACTION 0.25   
  52.  
  53.   /* What to multiply number of pixels mouse moved by to get rotation amount */
  54. #define EL_SENS   0.5
  55. #define AZ_SENS   0.5
  56.  
  57.   /* What to multiply number of pixels mouse moved by for movement amounts */
  58. #define DIST_SENS 0.01
  59. #define E_SENS    0.01
  60.  
  61.   /* Minimum spin to allow in polar (lower forced to zero) */
  62. #define MIN_AZSPIN 0.1
  63. #define MIN_ELSPIN 0.1
  64.  
  65.   /* Factors used in computing dAz and dEl (which determine AzSpin, ElSpin) */
  66. #define SLOW_DAZ 0.90
  67. #define SLOW_DEL 0.90
  68. #define PREV_DAZ 0.80
  69. #define PREV_DEL 0.80
  70. #define CUR_DAZ  0.20
  71. #define CUR_DEL  0.20
  72.  
  73. /***************************************************************/
  74. /************************** GLOBALS ****************************/
  75. /***************************************************************/
  76.  
  77. int     MoveMode = INIT_MODE;  /* FLYING or POLAR mode? */
  78.  
  79. GLfloat Ex = INIT_EX,             /* flying parameters */
  80.         Ey = INIT_EY,
  81.         Ez = INIT_EZ,
  82.         EyeMove = INIT_MOVE,     
  83.  
  84.         EyeDist = INIT_DIST,      /* polar params */
  85.         AzSpin  = INIT_AZ_SPIN,
  86.         ElSpin  = INIT_EL_SPIN,
  87.  
  88.         EyeAz = INIT_POLAR_AZ,    /* used by both */
  89.         EyeEl = INIT_POLAR_EL;
  90.  
  91. int agvMoving;    /* Currently moving?  */
  92.  
  93. int downx, downy,   /* for tracking mouse position */
  94.     lastx, lasty,
  95.     downb = -1;     /* and button status */
  96.                         
  97. GLfloat downDist, downEl, downAz, /* for saving state of things */
  98.         downEx, downEy, downEz,   /* when button is pressed */
  99.         downEyeMove;                
  100.  
  101. GLfloat dAz, dEl, lastAz, lastEl;  /* to calculate spinning w/ polar motion */
  102. int     AdjustingAzEl = 0;
  103.  
  104. int AllowIdle, RedisplayWindow; 
  105.    /* If AllowIdle is 1 it means AGV will install its own idle which
  106.     * will update the viewpoint as needed and send glutPostRedisplay() to the
  107.     * window RedisplayWindow which was set in agvInit().  AllowIdle of 0
  108.     * means AGV won't install an idle funciton, and something like
  109.     * "if (agvMoving) agvMove()" should exist at the end of the running
  110.     * idle function.
  111.     */
  112.  
  113. #define PI            3.14159265358979323846
  114. #define MAX(x,y) (((x) > (y)) ? (x) : (y))
  115. #define TORAD(x) ((PI/180.0)*(x))
  116. #define TODEG(x) ((180.0/PI)*(x))
  117.  
  118. /***************************************************************/
  119. /************************ PROTOTYPES ***************************/
  120. /***************************************************************/
  121.  
  122.   /*
  123.    * these are functions meant for internal use only
  124.    * the other prototypes are in agviewer.h
  125.    */
  126.  
  127. void PolarLookFrom(GLfloat dist, GLfloat elevation, GLfloat azimuth);
  128. void FlyLookFrom(GLfloat x, GLfloat y, GLfloat z, GLfloat az, GLfloat el);
  129. int  ConstrainEl(void);
  130. void MoveOn(int v);
  131. void SetMove(float newmove);
  132. void normalize(GLfloat v[3]);
  133. void ncrossprod(float v1[3], float v2[3], float cp[3]);
  134.  
  135.  
  136. /***************************************************************/
  137. /************************ agvInit ******************************/
  138. /***************************************************************/
  139.  
  140. void agvInit(int window)
  141. {
  142.   glutMouseFunc(agvHandleButton);
  143.   glutMotionFunc(agvHandleMotion);
  144.   glutKeyboardFunc(agvHandleKeys);
  145.   RedisplayWindow = glutGetWindow();
  146.   agvSetAllowIdle(window);
  147. }
  148.  
  149. /***************************************************************/
  150. /************************ VIEWPOINT STUFF **********************/
  151. /***************************************************************/
  152.  
  153.   /*
  154.    * viewing transformation modified from page 90 of red book
  155.    */
  156. void PolarLookFrom(GLfloat dist, GLfloat elevation, GLfloat azimuth)
  157. {
  158.   glTranslatef(0, 0, -dist);
  159.   glRotatef(elevation, 1, 0, 0);
  160.   glRotatef(azimuth, 0, 1, 0);
  161.  
  162. }
  163.  
  164.   /*
  165.    * I took the idea of tracking eye position in absolute
  166.    * coords and direction looking in Polar form from denis
  167.    */
  168. void FlyLookFrom(GLfloat x, GLfloat y, GLfloat z, GLfloat az, GLfloat el)
  169. {
  170.   float lookat[3], perp[3], up[3];
  171.  
  172.   lookat[0] = sin(TORAD(az))*cos(TORAD(el));
  173.   lookat[1] = sin(TORAD(el));
  174.   lookat[2] = -cos(TORAD(az))*cos(TORAD(el));
  175.   normalize(lookat);
  176.   perp[0] = lookat[2];
  177.   perp[1] = 0;
  178.   perp[2] = -lookat[0];
  179.   normalize(perp);
  180.   ncrossprod(lookat, perp, up);
  181.   gluLookAt(x, y, z,
  182.             x+lookat[0], y+lookat[1], z+lookat[2],
  183.             up[0], up[1], up[2]);
  184. }
  185.  
  186.   /*
  187.    * Call viewing transformation based on movement mode
  188.    */
  189. void agvViewTransform(void)
  190. { 
  191.   switch (MoveMode) {
  192.     case FLYING:
  193.       FlyLookFrom(Ex, Ey, Ez, EyeAz, EyeEl);
  194.       break;
  195.     case POLAR:
  196.       PolarLookFrom(EyeDist, EyeEl, EyeAz);
  197.       break;
  198.     }
  199. }
  200.  
  201.   /*
  202.    * keep them vertical; I think this makes a lot of things easier, 
  203.    * but maybe it wouldn't be too hard to adapt things to let you go
  204.    * upside down
  205.    */
  206. int ConstrainEl(void)
  207. {
  208.   if (EyeEl <= -90) {
  209.     EyeEl = -89.99;
  210.     return 1;
  211.   } else if (EyeEl >= 90) {
  212.     EyeEl = 89.99;
  213.     return 1;
  214.   }
  215.   return 0;
  216. }
  217.  
  218.  /*
  219.   * Idle Function - moves eyeposition
  220.   */
  221. void agvMove(void)
  222. {
  223.  
  224.   switch (MoveMode)  {
  225.     case FLYING:
  226.       Ex += EyeMove*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  227.       Ey += EyeMove*sin(TORAD(EyeEl));
  228.       Ez -= EyeMove*cos(TORAD(EyeAz))*cos(TORAD(EyeEl));
  229.       break;
  230.  
  231.     case POLAR:
  232.       EyeEl += ElSpin;
  233.       EyeAz += AzSpin;
  234.       if (ConstrainEl()) {  /* weird spin thing to make things look     */
  235.         ElSpin = -ElSpin;      /* look better when you are kept from going */
  236.                                /* upside down while spinning - Isn't great */
  237.         if (fabs(ElSpin) > fabs(AzSpin))
  238.           AzSpin = fabs(ElSpin) * ((AzSpin > 0) ? 1 : -1);
  239.       }
  240.       break;
  241.     }
  242.  
  243.   if (AdjustingAzEl) {
  244.     dAz *= SLOW_DAZ;
  245.     dEl *= SLOW_DEL;
  246.   }
  247.  
  248.   if (AllowIdle) {
  249.     glutSetWindow(RedisplayWindow);
  250.     glutPostRedisplay();
  251.   }
  252. }
  253.  
  254.  
  255.   /*
  256.    * Don't install agvMove as idle unless we will be updating the view
  257.    * and we've been given a RedisplayWindow
  258.    */
  259. void MoveOn(int v)
  260. {
  261.   if (v && ((MoveMode == FLYING && EyeMove != 0) ||
  262.              (MoveMode == POLAR &&
  263.              (AzSpin != 0 || ElSpin != 0 || AdjustingAzEl)))) {
  264.     agvMoving = 1;
  265.     if (AllowIdle)
  266.       glutIdleFunc(agvMove);
  267.   } else {
  268.     agvMoving = 0;
  269.     if (AllowIdle)
  270.       glutIdleFunc(NULL);
  271.   }
  272. }
  273.  
  274.   /*
  275.    * set new redisplay window.  If <= 0 it means we are not to install
  276.    * an idle function and will rely on whoever does install one to 
  277.    * put statement like "if (agvMoving) agvMove();" at end of it
  278.    */
  279. void agvSetAllowIdle(int allowidle)
  280. {
  281.   if ((AllowIdle = allowidle))
  282.     MoveOn(1);
  283. }
  284.  
  285.  
  286.   /*
  287.    * when moving to flying we stay in the same spot, moving to polar we
  288.    * reset since we have to be looking at the origin (though a pivot from
  289.    * current position to look at origin might be cooler)
  290.    */
  291. void agvSwitchMoveMode(int move)
  292. {
  293.   switch (move) {
  294.     case FLYING:
  295.       Ex    = -EyeDist*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  296.       Ey    =  EyeDist*sin(TORAD(EyeEl));
  297.       Ez    =  EyeDist*(cos(TORAD(EyeAz))*cos(TORAD(EyeEl)));
  298.       EyeAz =  EyeAz;
  299.       EyeEl = -EyeEl;
  300.       EyeMove = INIT_MOVE;
  301.       break;
  302.     case POLAR:
  303.       EyeDist = INIT_DIST;
  304.       EyeAz   = INIT_POLAR_AZ;
  305.       EyeEl   = INIT_POLAR_EL;
  306.       AzSpin  = INIT_AZ_SPIN;
  307.       ElSpin  = INIT_EL_SPIN;
  308.       break;
  309.     }
  310.   MoveMode = move;
  311.   MoveOn(1);
  312.   glutPostRedisplay();
  313. }
  314.  
  315. /***************************************************************/
  316. /*******************    MOUSE HANDLING   ***********************/
  317. /***************************************************************/
  318.  
  319. void agvHandleButton(int button, int state, int x, int y)
  320. {
  321.  if (state == GLUT_DOWN && downb == -1) {  
  322.     lastx = downx = x;
  323.     lasty = downy = y;
  324.     downb = button;    
  325.  
  326.     switch (button) {
  327.       case GLUT_LEFT_BUTTON:
  328.         lastEl = downEl = EyeEl;
  329.         lastAz = downAz = EyeAz;
  330.         AzSpin = ElSpin = dAz = dEl = 0;
  331.         AdjustingAzEl = 1;
  332.     MoveOn(1);
  333.         break;
  334.  
  335.       case GLUT_MIDDLE_BUTTON:
  336.         downDist = EyeDist;
  337.     downEx = Ex;
  338.     downEy = Ey;
  339.     downEz = Ez;
  340.     downEyeMove = EyeMove;
  341.     EyeMove = 0;
  342.     }
  343.  
  344.   } else if (state == GLUT_UP && button == downb) {
  345.  
  346.     downb = -1;
  347.  
  348.     switch (button) {
  349.       case GLUT_LEFT_BUTTON:
  350.         if (MoveMode != FLYING) {
  351.       AzSpin =  -dAz;
  352.       if (AzSpin < MIN_AZSPIN && AzSpin > -MIN_AZSPIN)
  353.         AzSpin = 0;    
  354.       ElSpin = -dEl;
  355.       if (ElSpin < MIN_ELSPIN && ElSpin > -MIN_ELSPIN)
  356.         ElSpin = 0; 
  357.     }
  358.         AdjustingAzEl = 0;
  359.         MoveOn(1);
  360.     break;
  361.  
  362.       case GLUT_MIDDLE_BUTTON:
  363.     EyeMove = downEyeMove;
  364.       }
  365.   }
  366. }
  367.  
  368.  /*
  369.   * change EyeEl and EyeAz and position when mouse is moved w/ button down
  370.   */
  371. void agvHandleMotion(int x, int y)
  372. {
  373.   int deltax = x - downx, deltay = y - downy;
  374.  
  375.   switch (downb) {
  376.     case GLUT_LEFT_BUTTON:
  377.       EyeEl  = downEl + EL_SENS * ((MoveMode == FLYING) ? -deltay : deltay);
  378.       ConstrainEl();
  379.       EyeAz  = downAz + AZ_SENS * deltax;
  380.       dAz    = PREV_DAZ*dAz + CUR_DAZ*(lastAz - EyeAz);
  381.       dEl    = PREV_DEL*dEl + CUR_DEL*(lastEl - EyeEl);
  382.       lastAz = EyeAz;
  383.       lastEl = EyeEl;
  384.       break;
  385.     case GLUT_MIDDLE_BUTTON:
  386.         EyeDist = downDist + DIST_SENS*deltay;
  387.         Ex = downEx - E_SENS*deltay*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  388.         Ey = downEy - E_SENS*deltay*sin(TORAD(EyeEl));
  389.         Ez = downEz + E_SENS*deltay*cos(TORAD(EyeAz))*cos(TORAD(EyeEl));
  390.       break;
  391.   }
  392.   glutPostRedisplay();
  393. }
  394.  
  395. /***************************************************************/
  396. /********************* KEYBOARD HANDLING ***********************/
  397. /***************************************************************/
  398.  
  399.   /*
  400.    * set EyeMove (current speed) for FLYING mode
  401.    */
  402. void SetMove(float newmove)
  403. {
  404.   if (newmove > MINMOVE) {
  405.     EyeMove = newmove;
  406.     MoveOn(1);
  407.   } else {
  408.     EyeMove = 0;
  409.     MoveOn(0);
  410.   }
  411. }
  412.  
  413.   /*
  414.    * 0->9 set speed, +/- adjust current speed  -- in FLYING mode
  415.    */
  416. void agvHandleKeys(unsigned char key, int x, int y)
  417. {
  418.   if (MoveMode != FLYING)
  419.     return;
  420.  
  421.   if (key >= '0' && key <= '9')
  422.     SetMove(SPEEDFUNCTION((key-'0')));
  423.   else
  424.     switch(key) {
  425.       case '+':  
  426.         if (EyeMove == 0)
  427.           SetMove(MINMOVE);
  428.          else
  429.       SetMove(EyeMove *= (1 + MOVEFRACTION));
  430.         break;
  431.       case '-':
  432.     SetMove(EyeMove *= (1 - MOVEFRACTION));
  433.         break;
  434.     }
  435. }
  436.  
  437. /***************************************************************/
  438. /*********************** VECTOR STUFF **************************/
  439. /***************************************************************/
  440.  
  441.   /* normalizes v */
  442. void normalize(GLfloat v[3])
  443. {
  444.   GLfloat d = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  445.  
  446.   if (d == 0)
  447.     fprintf(stderr, "Zero length vector in normalize\n");
  448.   else
  449.     v[0] /= d; v[1] /= d; v[2] /= d;
  450. }
  451.  
  452.   /* calculates a normalized crossproduct to v1, v2 */
  453. void ncrossprod(float v1[3], float v2[3], float cp[3])
  454. {
  455.   cp[0] = v1[1]*v2[2] - v1[2]*v2[1];
  456.   cp[1] = v1[2]*v2[0] - v1[0]*v2[2];
  457.   cp[2] = v1[0]*v2[1] - v1[1]*v2[0];
  458.   normalize(cp);
  459. }
  460.  
  461. /***************************************************************/
  462. /**************************** AXES *****************************/
  463. /***************************************************************/
  464.  
  465.  
  466.   /* draw axes -- was helpful to debug/design things */
  467. void agvMakeAxesList(int displaylistnum)
  468. {
  469.   int i,j;
  470.   GLfloat axes_ambuse[] =   { 0.5, 0.0, 0.0, 1.0 };
  471.   glNewList(displaylistnum, GL_COMPILE);
  472.   glPushAttrib(GL_LIGHTING_BIT);
  473.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, axes_ambuse);
  474.     glBegin(GL_LINES);
  475.       glVertex3f(15, 0, 0); glVertex3f(-15, 0, 0);
  476.       glVertex3f(0, 15, 0); glVertex3f(0, -15, 0);
  477.       glVertex3f(0, 0, 15); glVertex3f(0, 0, -15);
  478.     glEnd();
  479.     for (i = 0; i < 3; i++) {
  480.       glPushMatrix();
  481.         glTranslatef(-10*(i==0), -10*(i==1), -10*(i==2));
  482.         for (j = 0; j < 21; j++) {
  483.           glutSolidCube(0.1);
  484.           glTranslatef(i==0, i==1, i==2);
  485.     }
  486.       glPopMatrix();
  487.     }
  488.   glPopAttrib();
  489.   glEndList();  
  490. }
  491.  
  492.  
  493.